
using Microsoft.VisualStudio.TestTools.UnitTesting;

using System.Collections.Generic;

using Weazel.Gezel.Model;
using Weazel.Gezel.Model.Errors;
using Weazel.Math;

namespace Weazel.Gezel.Parser.Test
{
  [TestClass]
  public class TestParseExpression
  {
    /*
    [TestMethod]
    public void TestFinishDirective()
    {
      List<ParseError> errors = new List<ParseError>();
      Tokenizer t = new Tokenizer("$finish;");

      ParseExpression e = new ParseExpression();
      e.Parse(new Set<Token>(Token.Eof), t);      
    }
    */
  }
}
//    public TestParseExpression()
//    {
//
//    }
//
//    /// <summary>
//    /// Note that empty expressions are not allowed!
//    /// </summary>
//    [TestMethod]
//    public void TestEmptyExpression()
//    {
//      List<ParseError> errors = new List<ParseError>();
//      Tokenizer t = new Tokenizer(";");
//
//      try
//      {
//        ParseExpression.Parse(ref errors, null, t);
//        Assert.Fail();
//      }
//      catch (ParseException)
//      {
//
//      }
//    }
//
//    [TestMethod]
//    public void TestFinishDirective()
//    {
//      List<ParseError> errors = new List<ParseError>();
//      Tokenizer t = new Tokenizer("$finish;");
//
//      Expression expr = ParseExpression.Parse(ref errors, null, t);
//      Assert.AreEqual(expr.ExpressionType, ExpressionType.FinishDirective);
//
//      Assert.AreEqual(errors.Count, 0);
//      t.PopToken(Token.Semicolon);
//      t.PopToken(Token.Eof);
//    }
//
//    [TestMethod]
//    public void TestDisplayDirective()
//    {
//      List<ParseError> errors = new List<ParseError>();
//      Tokenizer t = new Tokenizer("$display(\"Hello, World!\");");
//
//      Expression expr = ParseExpression.Parse(ref errors, null, t);
//      t.PopToken(Token.Semicolon);
//      t.PopToken(Token.Eof);
//
//      Assert.AreEqual(errors.Count, 0);
//      Assert.AreEqual(expr.ExpressionType, ExpressionType.DisplayDirective);
//      Expression[] arguments = 
//              (expr as DirectiveExpression).Arguments;
//      Assert.AreEqual(arguments.Length, 1);
//      Assert.AreEqual(arguments[0].ExpressionType, ExpressionType.Str);
//
//      t = new Tokenizer("$display($dp, $sfg, $cycle, ident, \"Hello, World!\");");
//
//      expr = ParseExpression.Parse(ref errors, null, t);
//      t.PopToken(Token.Semicolon);
//      t.PopToken(Token.Eof);
//
//      Assert.AreEqual(errors.Count, 0);
//      arguments =
//              (expr as DirectiveExpression).Arguments;
//      Assert.AreEqual(arguments.Length, 5);
//      Assert.AreEqual(arguments[0].ExpressionType, ExpressionType.DatapathDirective);
//      Assert.AreEqual(arguments[1].ExpressionType, ExpressionType.SfgDirective);
//      Assert.AreEqual(arguments[2].ExpressionType, ExpressionType.CycleDirective);
//      Assert.AreEqual(arguments[3].ExpressionType, ExpressionType.Identifier);
//      Assert.AreEqual(arguments[4].ExpressionType, ExpressionType.Str);
//    }
//
//    [TestMethod]
//    public void TestAssignmentExpression()
//    {
//      List<ParseError> errors = new List<ParseError>();
//      Tokenizer t = new Tokenizer("leftChild = 2;");
//      Expression expr = ParseExpression.Parse(ref errors, null, t);
//
//      t.PopToken(Token.Semicolon);
//      t.PopToken(Token.Eof);
//
//      Assert.AreEqual(errors.Count, 0);
//      Assert.AreEqual(expr.ExpressionType, ExpressionType.Assignment);
//      Assert.IsTrue(expr is BinaryExpression);
//      Assert.IsTrue((expr as BinaryExpression).LeftChild is LeafExpression);
//      Assert.IsTrue((expr as BinaryExpression).RightChild is LeafExpression);
//
//      t = new Tokenizer("leftChild = rightChild = c = 2;");
//      expr = ParseExpression.Parse(ref errors, null, t);
//
//      t.PopToken(Token.Semicolon);
//      t.PopToken(Token.Eof);
//
//      Assert.AreEqual(errors.Count, 0);
//      Assert.AreEqual(expr.ExpressionType, ExpressionType.Assignment);
//      Assert.IsTrue(expr is BinaryExpression);
//      Assert.IsTrue((expr as BinaryExpression).LeftChild is LeafExpression);
//      Assert.IsTrue((expr as BinaryExpression).RightChild is BinaryExpression);
//    }
//  }
//}
